home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / exampleCode / GLX / texvol / matrix.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  10.9 KB  |  438 lines
  1. /*
  2.  * Copyright (C) 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /*----------------------------------------------------------------------------
  18.  *
  19.  * file   : matrix.c 
  20.  *
  21.  * Author : Yusuf Attarwala
  22.  * Date   : Sep 93
  23.  *
  24.  *---------------------------------------------------------------------------*/
  25. #include <math.h>
  26.  
  27. #include "globals_vol.h"
  28.  
  29. #define PI 3.141592
  30.  
  31. setProjView(which_trans)
  32. int which_trans;
  33. {
  34.  
  35.     switch(which_trans) {
  36.     case PROJ_TRANSF :
  37.         mmode(MPROJECTION);
  38.         ortho(left,right,bottom,top,near,far);
  39.  
  40.         x_world_per_pixel = (right-left)/(wmaxx-wminx);
  41.         y_world_per_pixel = (top-bottom)/(wmaxy-wminy);
  42.     world_aspect      = (right-left)/(top-bottom);
  43.  
  44.     computeWorldToScreenRatio();
  45.         break;
  46.  
  47.     case VIEW_TRANSF :
  48.         mmode(MVIEWING);
  49.         loadmatrix(identity);
  50.         polarview((Coord)distance,
  51.                   (Angle)azimuth,(Angle)incidence,(Angle)twist);
  52.         getmatrix(vmat);
  53.         break;
  54.  
  55.     case MODL_TRANSF :
  56.     mmode(MVIEWING);
  57.         loadmatrix(identity);
  58.         if (screenAxes) {
  59.         /*
  60.             translate(pivotx,pivoty,pivotz);
  61.         */
  62.         }
  63.     else {
  64.         multmatrix(mmat);
  65.         /*
  66.             translate(pivotx,pivoty,pivotz);
  67.         */
  68.     }
  69.         if (anglex != 0) {
  70.             rotate(-(int)(anglex*rotn_sens),'x');
  71.         if (!trackBall) anglex = 0;
  72.         }
  73.         if (angley != 0) {
  74.             rotate(-(int)(angley*rotn_sens),'y');
  75.         if (!trackBall) angley = 0;
  76.         }
  77.         if (anglez != 0) {
  78.             rotate(-(int)(anglez*rotn_sens),'z');
  79.         if (!trackBall) anglez = 0;
  80.         }
  81.  
  82.         if (screenAxes) {
  83.         /*
  84.             translate(-pivotx,-pivoty,-pivotz);
  85.         */
  86.         multmatrix(mmat);
  87.         getmatrix(mmat);
  88.         }
  89.         else {
  90.         /*
  91.             translate(-pivotx,-pivoty,-pivotz);
  92.         */
  93.             getmatrix(mmat);
  94.         }
  95.         break;
  96.     default :
  97.     break;
  98.     } /* switch */
  99.  
  100.     mmode(MVIEWING);
  101. loadmatrix(identity);
  102.     loadmatrix(vmat);
  103.     multmatrix(mmat); 
  104.  
  105.     refresh = TRUE;
  106.  
  107.     if (degenMode && !trackBall) {
  108.     intoDegenerate();
  109.     }
  110.  
  111. } /* set_proj_view */
  112.  
  113. void
  114. computeProjectionView()
  115. {
  116.     float a;
  117.  
  118.     reset_left   = left      = -1.1 * bdiag;
  119.     reset_right  = right     = 1.1 *  bdiag;
  120.     reset_bottom = bottom    = -1.1 * bdiag;
  121.     reset_top    = top       = 1.1 *  bdiag;
  122.     reset_near   = near      = -1.0 * bdiag;
  123.     reset_far    = far       = 2* 1.1 *  bdiag;
  124.  
  125.     reset_azimuth   = azimuth   = 0.0;
  126.     reset_incidence = incidence = 0.0;
  127.     reset_twist     = twist     = 0.0;
  128.     reset_distance  = distance  = 1.1 * bdiag;
  129.  
  130.     reset_anglex = anglex = 0;
  131.     reset_angley = angley = 0;
  132.     reset_anglez = anglez = 0;
  133.  
  134.     /*
  135.     setProjView(PROJ_TRANSF);
  136.     setProjView(VIEW_TRANSF);
  137.     */
  138. }
  139.  
  140. copy_matrix(from,to)
  141. Matrix from,to;
  142. /*----------------------------------------------------------------------------
  143.  
  144.  ----------------------------------------------------------------------------*/
  145. {
  146.     memcpy(to,from,sizeof(Matrix));
  147. } /* copy_matrix */
  148.  
  149. computeWorldToScreenRatio()
  150. /*----------------------------------------------------------------------------
  151.  
  152.  ----------------------------------------------------------------------------*/
  153. {
  154.     x_world_per_pixel = (right-left)/ (window_width);
  155.     y_world_per_pixel = (top-bottom)/ (window_height);
  156.     world_aspect      = (right-left)/ (top-bottom);
  157.  
  158.     rotn_sens         = 3600/(2.*window_width);
  159. }
  160.  
  161. invert4d(from,to)
  162. Matrix from,to;
  163. /*---------------------------------------------------------------------
  164.  *
  165.  *------------------------------------------------------------------ */
  166. {
  167.     float wtemp[4][8];
  168.     register float m0,m1,m2,m3,s;
  169.     register float *r0,*r1,*r2,*r3, *rtemp;
  170.  
  171.     r0 = wtemp[0];
  172.     r1 = wtemp[1];
  173.     r2 = wtemp[2];
  174.     r3 = wtemp[3];
  175.     r0[0] = from[0][0];         /* build up [A][I]      */
  176.     r0[1] = from[0][1];
  177.     r0[2] = from[0][2];
  178.     r0[3] = from[0][3];
  179.     r0[4] = 1.0;
  180.     r0[5] = 0.0;
  181.     r0[6] = 0.0;
  182.     r0[7] = 0.0;
  183.     r1[0] = from[1][0];
  184.     r1[1] = from[1][1];
  185.     r1[2] = from[1][2];
  186.     r1[3] = from[1][3];
  187.     r1[4] = 0.0;
  188.     r1[5] = 1.0;
  189.     r1[6] = 0.0;
  190.     r1[7] = 0.0;
  191.     r2[0] = from[2][0];
  192.     r2[1] = from[2][1];
  193.     r2[2] = from[2][2];
  194.     r2[3] = from[2][3];
  195.     r2[4] = 0.0;
  196.     r2[5] = 0.0;
  197.     r2[6] = 1.0;
  198.     r2[7] = 0.0;
  199.     r3[0] = from[3][0];
  200.     r3[1] = from[3][1];
  201.     r3[2] = from[3][2];
  202.     r3[3] = from[3][3];
  203.     r3[4] = 0.0;
  204.     r3[5] = 0.0;
  205.     r3[6] = 0.0;
  206.     r3[7] = 1.0;
  207.     if (r0[0] == 0.0) {         /* swap rows if needed          */
  208.         if (r1[0] == 0.0) {
  209.             if (r2[0] == 0.0) {
  210.                 if (r3[0] == 0.0) goto singular;
  211.                 rtemp = r0; r0 = r3; r3 = rtemp;
  212.             }
  213.             else {rtemp = r0; r0 = r2; r2 = rtemp;}
  214.         }
  215.         else {rtemp = r0; r0 = r1; r1 = rtemp;}
  216.     }
  217.     m1 = r1[0]/r0[0];           /* eliminate first variable     */
  218.     m2 = r2[0]/r0[0];
  219.     m3 = r3[0]/r0[0];
  220.     s = r0[1];    
  221.     r1[1] = r1[1] - m1 * s;
  222.     r2[1] = r2[1] - m2 * s;
  223.     r3[1] = r3[1] - m3 * s;
  224.     s = r0[2];
  225.     r1[2] = r1[2] - m1 * s;
  226.     r2[2] = r2[2] - m2 * s;
  227.     r3[2] = r3[2] - m3 * s;
  228.     s = r0[3];
  229.     r1[3] = r1[3] - m1 * s;
  230.     r2[3] = r2[3] - m2 * s;
  231.     r3[3] = r3[3] - m3 * s;
  232.     s = r0[4];
  233.     if (s != 0.0) {
  234.         r1[4] = r1[4] - m1 * s;
  235.         r2[4] = r2[4] - m2 * s;
  236.         r3[4] = r3[4] - m3 * s;
  237.     }
  238.     s = r0[5];
  239.     if (s != 0.0) {
  240.         r1[5] = r1[5] - m1 * s;
  241.         r2[5] = r2[5] - m2 * s;
  242.         r3[5] = r3[5] - m3 * s;
  243.     }
  244.     s = r0[6];
  245.     if (s != 0.0) {
  246.         r1[6] = r1[6] - m1 * s;
  247.         r2[6] = r2[6] - m2 * s;
  248.         r3[6] = r3[6] - m3 * s;
  249.     }
  250.     s = r0[7];
  251.     if (s != 0.0) {
  252.         r1[7] = r1[7] - m1 * s;
  253.         r2[7] = r2[7] - m2 * s;
  254.         r3[7] = r3[7] - m3 * s;
  255.     }
  256.     if (r1[1] == 0.0) {         /* swap rows if needed          */
  257.         if (r2[1] == 0.0) {
  258.             if (r3[1] == 0.0) goto singular;
  259.             rtemp = r1; r1 = r3; r3 = rtemp;
  260.         }
  261.         else {rtemp = r1; r1 = r2; r2 = rtemp;}
  262.     }
  263.     m2 = r2[1]/r1[1];           /* eliminate second variable    */
  264.     m3 = r3[1]/r1[1];
  265.     r2[2] = r2[2] - m2 * r1[2];
  266.     r3[2] = r3[2] - m3 * r1[2];
  267.     r3[3] = r3[3] - m3 * r1[3];
  268.     r2[3] = r2[3] - m2 * r1[3];
  269.     s = r1[4];
  270.     if (s != 0.0) {
  271.         r2[4] = r2[4] - m2 * s;
  272.         r3[4] = r3[4] - m3 * s;
  273.     }
  274.     s = r1[5];
  275.     if (s != 0.0) {
  276.         r2[5] = r2[5] - m2 * s;
  277.         r3[5] = r3[5] - m3 * s;
  278.     }
  279.     s = r1[6];
  280.     if (s != 0.0) {
  281.         r2[6] = r2[6] - m2 * s;
  282.         r3[6] = r3[6] - m3 * s;
  283.     }
  284.     s = r1[7];
  285.     if (s != 0.0) {
  286.         r2[7] = r2[7] - m2 * s;
  287.         r3[7] = r3[7] - m3 * s;
  288.     } 
  289.  
  290.     if (r2[2] == 0.0) {         /* swap last 2 rows if needed   */
  291.         if (r3[2] == 0.0) goto singular;
  292.         rtemp = r2; r2 = r3; r3 = rtemp;
  293.     }
  294.     m3 = r3[2]/r2[2];           /* eliminate third variable     */
  295.     r3[3] = r3[3] - m3 * r2[3];
  296.     r3[4] = r3[4] - m3 * r2[4];
  297.     r3[5] = r3[5] - m3 * r2[5];
  298.     r3[6] = r3[6] - m3 * r2[6];
  299.     r3[7] = r3[7] - m3 * r2[7];
  300.     if (r3[3] == 0.0) goto singular;
  301.     s = 1.0/r3[3];              /* now back substitute row 3    */
  302.     r3[4] = r3[4] * s;
  303.     r3[5] = r3[5] * s;
  304.     r3[6] = r3[6] * s;
  305.     r3[7] = r3[7] * s;
  306.     m2 = r2[3];                 /* now back substitute row 2    */
  307.     s = 1.0/r2[2];
  308.     r2[4] = s * (r2[4] - r3[4] * m2);
  309.     r2[5] = s * (r2[5] - r3[5] * m2);
  310.     r2[6] = s * (r2[6] - r3[6] * m2);
  311.     r2[7] = s * (r2[7] - r3[7] * m2);
  312.     m1 = r1[3];
  313.     r1[4] = (r1[4] - r3[4] * m1);
  314.     r1[5] = (r1[5] - r3[5] * m1);
  315.     r1[6] = (r1[6] - r3[6] * m1);
  316.     r1[7] = (r1[7] - r3[7] * m1);
  317.     m0 = r0[3];
  318.     r0[4] = (r0[4] - r3[4] * m0);
  319.     r0[5] = (r0[5] - r3[5] * m0);
  320.     r0[6] = (r0[6] - r3[6] * m0);
  321.     r0[7] = (r0[7] - r3[7] * m0);
  322.     m1 = r1[2];                 /* now back substitute row 1    */
  323.     s = 1.0/r1[1];
  324.     r1[4] = s * (r1[4] - r2[4] * m1);
  325.     r1[5] = s * (r1[5] - r2[5] * m1);
  326.     r1[6] = s * (r1[6] - r2[6] * m1);
  327.     r1[7] = s * (r1[7] - r2[7] * m1);
  328.     m0 = r0[2];
  329.     r0[4] = (r0[4] - r2[4] * m0);
  330.     r0[5] = (r0[5] - r2[5] * m0);
  331.     r0[6] = (r0[6] - r2[6] * m0);
  332.     r0[7] = (r0[7] - r2[7] * m0);
  333.     m0 = r0[1];                 /* now back substitute row 0    */
  334.     s = 1.0/r0[0];
  335.     r0[4] = s * (r0[4] - r1[4] * m0);
  336.     r0[5] = s * (r0[5] - r1[5] * m0);
  337.     r0[6] = s * (r0[6] - r1[6] * m0);
  338.     r0[7] = s * (r0[7] - r1[7] * m0);
  339.     to[0][0] = r0[4];           /* copy results back            */
  340.     to[0][1] = r0[5];
  341.     to[0][2] = r0[6];
  342.     to[0][3] = r0[7];
  343.     to[1][0] = r1[4];
  344.     to[1][1] = r1[5];
  345.     to[1][2] = r1[6];
  346.     to[1][3] = r1[7];
  347.     to[2][0] = r2[4];
  348.     to[2][1] = r2[5];
  349.     to[2][2] = r2[6];
  350.     to[2][3] = r2[7];
  351.     to[3][0] = r3[4];
  352.     to[3][1] = r3[5];
  353.     to[3][2] = r3[6];
  354.     to[3][3] = r3[7];
  355.     return;
  356.  
  357. singular:
  358.     printf ("ERROR : non_invertable transform\n");
  359.     return;
  360. }
  361.  
  362.  
  363. transform4d(f,t,m) 
  364. float f[4],t[4],m[4][4];
  365. /*---------------------------------------------------------------------
  366.  *
  367.  *------------------------------------------------------------------ */
  368. {
  369.     t[0] = f[0]*m[0][0] + f[1]*m[1][0] + f[2]*m[2][0] + f[3]*m[3][0];
  370.     t[1] = f[0]*m[0][1] + f[1]*m[1][1] + f[2]*m[2][1] + f[3]*m[3][1];
  371.     t[2] = f[0]*m[0][2] + f[1]*m[1][2] + f[2]*m[2][2] + f[3]*m[3][2];
  372.     t[3] = f[0]*m[0][3] + f[1]*m[1][3] + f[2]*m[2][3] + f[3]*m[3][3];
  373. }
  374.  
  375. normalize(xn,yn,zn)
  376. float *xn,*yn,*zn;
  377. {
  378.     double denom;
  379.  
  380.     denom = sqrt( (double)((*xn * *xn) + (*yn * *yn) + (*zn * *zn)));
  381.  
  382.     *xn = *xn/denom;
  383.     *yn = *yn/denom;
  384.     *zn = *zn/denom;
  385. }
  386.  
  387. void
  388. specificView(view)
  389. int view;
  390. /*---------------------------------------------------------------------
  391.  *
  392.  *------------------------------------------------------------------ */
  393. {
  394.     float a;
  395.     int ax = 0;
  396.     int save_rotn_sens = rotn_sens;
  397.  
  398.     if (trackBall) animation(0);
  399.  
  400.     copy_matrix(identity,mmat);
  401.  
  402.     twist = 0;
  403.     anglex  = angley  = anglez = 0;
  404.  
  405.     rotn_sens = 1;
  406.  
  407.     setProjView(MODL_TRANSF);
  408.  
  409.     switch (view) {
  410.     case 1 : /* +x */
  411.         angley = -900; 
  412.         break;
  413.     case 2 : /* +y */
  414.         anglex = 900;   
  415.         break;
  416.     case 3 : /* +z */
  417.         /* do nothing */ 
  418.         break;
  419.     case 4 : /* -x */
  420.         angley = 900;     
  421.         break;
  422.     case 5 : /* -y */
  423.         anglex = -900;     
  424.         break;
  425.     case 6 : /* -z */
  426.         angley = 1800;      
  427.         break;
  428.     default :
  429.         return;
  430.     }
  431.  
  432.     setProjView(MODL_TRANSF);
  433.     rotn_sens = save_rotn_sens;
  434.     drawScene();
  435.  
  436. }
  437.  
  438.